home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / misc / 40 / pager.c < prev    next >
C/C++ Source or Header  |  1986-07-17  |  9KB  |  411 lines
  1. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  2. /* pager.c - version 1.0.3 */
  3.  
  4. /* This file contains the command routine dowhatis() and a pager. */
  5. /* Also readmail() and doshell(), and generally the things that
  6.    contact the outside world. */
  7.  
  8. #include <stdio.h>
  9. #ifdef UNIX
  10. #include <signal.h>
  11. #endif
  12. #include "hack.h"
  13. extern int CO, LI;    /* usually COLNO and ROWNO+2 */
  14. extern char *CD;
  15. extern char quitchars[];
  16. extern char *getenv(), *getlogin();
  17. int done1();
  18.  
  19. dowhatis()
  20. {
  21.     FILE *fp;
  22.     char bufr[BUFSZ+6];
  23.     register char *buf = &bufr[6], *ep, q;
  24.     extern char readchar();
  25.  
  26.     if(!(fp = fopen("data","r")))
  27.         pline("Cannot open data file!");
  28.     else {
  29.         pline("Specify what? ");
  30.         q = readchar();
  31. #ifdef DGK
  32.         if (index(quitchars, q))
  33.             return(0);
  34. #endif DGK
  35.         if(q != '\t')
  36.         while(fgets(buf,BUFSZ,fp))
  37.             if(*buf == q) {
  38.             ep = index(buf, '\n');
  39.             if(ep) *ep = 0;
  40.             /* else: bad data file */
  41.             /* Expand tab 'by hand' */
  42.             if(buf[1] == '\t'){
  43.                 buf = bufr;
  44.                 buf[0] = q;
  45.                 (void) strncpy(buf+1, "       ", 7);
  46.             }
  47.             pline(buf);
  48.             if(ep[-1] == ';') {
  49.                 pline("More info? ");
  50.                 if(readchar() == 'y') {
  51.                     page_more(fp,1); /* does fclose() */
  52.                     return(0);
  53.                 }
  54.             }
  55.             (void) fclose(fp);     /* kopper@psuvax1 */
  56.             return(0);
  57.             }
  58.         pline("I've never heard of such things.");
  59.         (void) fclose(fp);
  60.     }
  61.     return(0);
  62. }
  63.  
  64. /* make the paging of a file interruptible */
  65. static int got_intrup;
  66.  
  67. intruph(){
  68.     got_intrup++;
  69. }
  70.  
  71. /* simple pager, also used from dohelp() */
  72. page_more(fp,strip)
  73. FILE *fp;
  74. int strip;    /* nr of chars to be stripped from each line (0 or 1) */
  75. {
  76.     register char *bufr, *ep;
  77. #ifdef UNIX
  78.     int (*prevsig)() = signal(SIGINT, intruph);
  79. #endif
  80.     set_pager(0);
  81.     bufr = (char *) alloc((unsigned) CO);
  82.     bufr[CO-1] = 0;
  83.     while(fgets(bufr,CO-1,fp) && (!strip || *bufr == '\t') && !got_intrup){
  84.         ep = index(bufr, '\n');
  85.         if(ep)
  86.             *ep = 0;
  87.         if(page_line(bufr+strip)) {
  88.             set_pager(2);
  89.             goto ret;
  90.         }
  91.     }
  92.     set_pager(1);
  93. ret:
  94.     free(bufr);
  95.     (void) fclose(fp);
  96. #ifdef UNIX
  97.     (void) signal(SIGINT, prevsig);
  98. #endif
  99.     got_intrup = 0;
  100. }
  101.  
  102. static boolean whole_screen = TRUE;
  103. #define    PAGMIN    12    /* minimum # of lines for page below level map */
  104.  
  105. set_whole_screen() {    /* called in termcap as soon as LI is known */
  106.     whole_screen = (LI-ROWNO-2 <= PAGMIN || !CD);
  107. }
  108.  
  109. #ifdef NEWS
  110. readnews() {
  111.     register int ret;
  112.  
  113.     whole_screen = TRUE;    /* force a docrt(), our first */
  114.     ret = page_file(NEWS, TRUE);
  115.     set_whole_screen();
  116.     return(ret);        /* report whether we did docrt() */
  117. }
  118. #endif NEWS
  119.  
  120. set_pager(mode)
  121. register int mode;    /* 0: open  1: wait+close  2: close */
  122. {
  123.     static boolean so;
  124.     if(mode == 0) {
  125.         if(!whole_screen) {
  126.             /* clear topline */
  127.             clrlin();
  128.             /* use part of screen below level map */
  129.             curs(1, ROWNO+4);
  130.         } else {
  131.             cls();
  132.         }
  133.         so = flags.standout;
  134.         flags.standout = 1;
  135.     } else {
  136.         if(mode == 1) {
  137.             curs(1, LI);
  138.             more();
  139.         }
  140.         flags.standout = so;
  141.         if(whole_screen)
  142.             docrt();
  143.         else {
  144.             curs(1, ROWNO+4);
  145.             cl_eos();
  146.         }
  147.     }
  148. }
  149.  
  150. page_line(s)        /* returns 1 if we should quit */
  151. register char *s;
  152. {
  153.     extern char morc;
  154.  
  155.     if(cury == LI-1) {
  156.         if(!*s)
  157.             return(0);    /* suppress blank lines at top */
  158.         putchar('\n');
  159.         cury++;
  160.         cmore("q\033");
  161.         if(morc) {
  162.             morc = 0;
  163.             return(1);
  164.         }
  165.         if(whole_screen)
  166.             cls();
  167.         else {
  168.             curs(1, ROWNO+4);
  169.             cl_eos();
  170.         }
  171.     }
  172.     puts(s);
  173.     cury++;
  174.     return(0);
  175. }
  176.  
  177. /*
  178.  * Flexible pager: feed it with a number of lines and it will decide
  179.  * whether these should be fed to the pager above, or displayed in a
  180.  * corner.
  181.  * Call:
  182.  *    cornline(0, title or 0)    : initialize
  183.  *    cornline(1, text)    : add text to the chain of texts
  184.  *    cornline(2, morcs)    : output everything and cleanup
  185.  *    cornline(3, 0)        : cleanup
  186.  */
  187.  
  188. cornline(mode, text)
  189. int mode;
  190. char *text;
  191. {
  192.     static struct line {
  193.         struct line *next_line;
  194.         char *line_text;
  195.     } *texthead, *texttail;
  196.     static int maxlen;
  197.     static int linect;
  198.     register struct line *tl;
  199.  
  200.     if(mode == 0) {
  201.         texthead = 0;
  202.         maxlen = 0;
  203.         linect = 0;
  204.         if(text) {
  205.             cornline(1, text);    /* title */
  206.             cornline(1, "");    /* blank line */
  207.         }
  208.         return;
  209.     }
  210.  
  211.     if(mode == 1) {
  212.         register int len;
  213.  
  214.         if(!text) return;    /* superfluous, just to be sure */
  215.         linect++;
  216.         len = strlen(text);
  217.         if(len > maxlen)
  218.         maxlen = len;
  219.         tl = (struct line *)
  220.         alloc((unsigned)(len + sizeof(struct line) + 1));
  221.         tl->next_line = 0;
  222.         tl->line_text = (char *)(tl + 1);
  223.         (void) strcpy(tl->line_text, text);
  224.         if(!texthead)
  225.         texthead = tl;
  226.         else
  227.         texttail->next_line = tl;
  228.         texttail = tl;
  229.         return;
  230.     }
  231.  
  232.     /* --- now we really do it --- */
  233.     if(mode == 2 && linect == 1)                /* topline only */
  234.         pline(texthead->line_text);
  235.     else
  236.     if(mode == 2) {
  237.         register int curline, lth;
  238.  
  239.         if(flags.toplin == 1) more();    /* ab@unido */
  240.         remember_topl();
  241.  
  242.         lth = CO - maxlen - 2;           /* Use full screen width */
  243.         if (linect < LI && lth >= 10) {             /* in a corner */
  244.         home ();
  245.         cl_end ();
  246.         flags.toplin = 0;
  247.         curline = 1;
  248.         for (tl = texthead; tl; tl = tl->next_line) {
  249.             curs (lth, curline);
  250.             if(curline > 1)
  251.             cl_end ();
  252.             putsym(' ');
  253.             putstr (tl->line_text);
  254.             curline++;
  255.         }
  256.         curs (lth, curline);
  257.         cl_end ();
  258.         cmore (text);
  259.         home ();
  260.         cl_end ();
  261.         docorner (lth, curline-1);
  262.         } else {                    /* feed to pager */
  263.         set_pager(0);
  264.         for (tl = texthead; tl; tl = tl->next_line) {
  265.             if (page_line (tl->line_text)) {
  266.             set_pager(2);
  267.             goto cleanup;
  268.             }
  269.         }
  270.         if(text) {
  271.             cgetret(text);
  272.             set_pager(2);
  273.         } else
  274.             set_pager(1);
  275.         }
  276.     }
  277.  
  278. cleanup:
  279.     while(tl = texthead) {
  280.         texthead = tl->next_line;
  281.         free((char *) tl);
  282.     }
  283. }
  284.  
  285. dohelp()
  286. {
  287.     char c;
  288.  
  289.     pline ("Long or short help? ");
  290.     while (((c = readchar ()) != 'l') && (c != 's') && !index(quitchars,c))
  291.         bell ();
  292.     if (!index(quitchars, c))
  293.         (void) page_file((c == 'l') ? HELP : SHELP, FALSE);
  294.     return(0);
  295. }
  296.  
  297. page_file(fnam, silent)    /* return: 0 - cannot open fnam; 1 - otherwise */
  298. register char *fnam;
  299. boolean silent;
  300. {
  301. #ifdef DEF_PAGER            /* this implies that UNIX is defined */
  302.       {
  303.     /* use external pager; this may give security problems */
  304.  
  305.     register int fd = open(fnam, 0);
  306.  
  307.     if(fd < 0) {
  308.         if(!silent) pline("Cannot open %s.", fnam);
  309.         return(0);
  310.     }
  311.     if(child(1)){
  312.         extern char *catmore;
  313.  
  314.         /* Now that child() does a setuid(getuid()) and a chdir(),
  315.            we may not be able to open file fnam anymore, so make
  316.            it stdin. */
  317.         (void) close(0);
  318.         if(dup(fd)) {
  319.             if(!silent) printf("Cannot open %s as stdin.\n", fnam);
  320.         } else {
  321.             execl(catmore, "page", (char *) 0);
  322.             if(!silent) printf("Cannot exec %s.\n", catmore);
  323.         }
  324.         exit(1);
  325.     }
  326.     (void) close(fd);
  327.       }
  328. #else DEF_PAGER
  329.       {
  330.     FILE *f;            /* free after Robert Viduya */
  331.  
  332.     if ((f = fopen (fnam, "r")) == (FILE *) 0) {
  333.         if(!silent) {
  334.             home(); perror (fnam); flags.toplin = 1;
  335.             pline ("Cannot open %s.", fnam);
  336.         }
  337.         return(0);
  338.     }
  339.     page_more(f, 0);
  340.       }
  341. #endif DEF_PAGER
  342.  
  343.     return(1);
  344. }
  345.  
  346. #ifdef UNIX
  347. #ifdef SHELL
  348. dosh(){
  349. register char *str;
  350.     if(child(0)) {
  351.         if(str = getenv("SHELL"))
  352.             execl(str, str, (char *) 0);
  353.         else
  354.             execl("/bin/sh", "sh", (char *) 0);
  355.         pline("sh: cannot execute.");
  356.         exit(1);
  357.     }
  358.     return(0);
  359. }
  360. #endif SHELL
  361.  
  362. #ifdef NOWAITINCLUDE
  363. union wait {        /* used only for the cast  (union wait *) 0  */
  364.     int w_status;
  365.     struct {
  366.         unsigned short w_Termsig:7;
  367.         unsigned short w_Coredump:1;
  368.         unsigned short w_Retcode:8;
  369.     } w_T;
  370. };
  371.  
  372. #else
  373.  
  374. #ifdef BSD
  375. #include    <sys/wait.h>
  376. #else
  377. #include    <wait.h>
  378. #endif BSD
  379. #endif NOWAITINCLUDE
  380.  
  381. child(wt) {
  382. register int f = fork();
  383.     if(f == 0){        /* child */
  384.         settty((char *) 0);        /* also calls end_screen() */
  385.         (void) setuid(getuid());
  386.         (void) setgid(getgid());
  387. #ifdef CHDIR
  388.         (void) chdir(getenv("HOME"));
  389. #endif CHDIR
  390.         return(1);
  391.     }
  392.     if(f == -1) {    /* cannot fork */
  393.         pline("Fork failed. Try again.");
  394.         return(0);
  395.     }
  396.     /* fork succeeded; wait for child to exit */
  397.     (void) signal(SIGINT,SIG_IGN);
  398.     (void) signal(SIGQUIT,SIG_IGN);
  399.     (void) wait((union wait *) 0);
  400.     gettty();
  401.     setftty();
  402.     (void) signal(SIGINT,done1);
  403. #ifdef WIZARD
  404.     if(wizard) (void) signal(SIGQUIT,SIG_DFL);
  405. #endif WIZARD
  406.     if(wt) getret();
  407.     docrt();
  408.     return(0);
  409. }
  410. #endif UNIX
  411.